package futbol.tacticas.concursantes.FCAlexB;

import futbol.tacticas.concursantes.Tactica;
import java.awt.*;
import java.util.Vector;
import futbol.*;
import futbol.tacticas.*;

public class TacticaAlex2 implements Tactica{
	  
    private int nValores[][]={
        {-150,0,8},  // Jugador 1[0]
        {-95,-10,9},  // Jugador 2[1]
        {-95,-65,9},  // Jugador 3[2]
        {-60,10,5},  // Jugador 4[3]
        {-95,65,9},  // Jugador 5[4]
        {0,-85,6},  // Jugador 6[5]
        {10,0,6},  // Jugador 7[6]
        {0,85,6},  // Jugador 8[7]
        {105,-75,8},  // Jugador 9[8]
        {90,0,6},  // Jugador 10[9]
        {105,75,8}  // Jugador 11[10]
    };
    
    private int destinoPase=-1;
    private double x0=0;
    private double y0=0;
    
    public Color getColor1() {
        return Color.RED;
    }

    public Color getColor2() {
        return Color.YELLOW;
    }

    public Color getColorNumero() {
        return Color.blue;
    }

    public String getNombre() {
        return "F.C. Alex B";
    }

    public int getXInicial(int n) {
        return nValores[n][0];
    }

    public int getYInicial(int n) {
        return nValores[n][1];
    }

    public int getFuerza(int n) {
        return nValores[n][2];
    }

    public Vector<Comando> getComandos(SituacionJugadores sj) {
        Vector<Comando> com=new Vector();
      
        //Coger balon, posiciones mias y del contrario
        Point bola=sj.getBola();
        Point[] posicionJugadores=sj.getMisJugadores();
        Point[] posicionContrarios=sj.getContrario();
        
        
        //Verificar si el pase no ha sido interceptado
        if (!sj.estoyMasCercaDeBola()){
        	destinoPase=-1;    		
        }
        
        //Movimiento de jugadores
        if (destinoPase==-1){
        	for (int n=0;n<11;n++)
        		com.add(new ComandoIrA(n,nValores[n][0],nValores[n][1]));
        } else {
        	for (int n=0;n<destinoPase;n++){
        		com.add(new ComandoIrA(n,nValores[n][0],nValores[n][1]));
        	}
        	com.add(new ComandoIrA(destinoPase,bola.getX(),bola.getY()));
        	for (int n=destinoPase+1;n<11;n++){
        		com.add(new ComandoIrA(n,nValores[n][0],nValores[n][1]));
        	}
        }
        	
        //Defensa sin baln, jugadores 2,3,4,5([1],[2],[3],[4])
        if (bola.x<1){
        	for(int i=1;i<5;i++){
        		int a = sj.getContrarioMasCerca(i);
        		if (!sj.estoyMasCercaDeBola() && i==sj.getMiJugadorMasCerca(posicionContrarios[a].getX(), posicionContrarios[a].getY())){
        			if (bola.getY()>posicionJugadores[i].getY()){
        				com.add(new ComandoIrA(i,posicionContrarios[a].getX()+15, posicionContrarios[a].getY()+10));
        			}else if (bola.getY()<posicionJugadores[i].getY()){
        				com.add(new ComandoIrA(i,posicionContrarios[a].getX()+15, posicionContrarios[a].getY()-10));
        			}else{
        				com.add(new ComandoIrA(i,posicionContrarios[a].getX()+15, posicionContrarios[a].getY()));
        			}
        		}
        	}
        //Defensa y medio campo sin baln (hasta el 8[7])
        } else if (bola.x<75){
        	for(int i=1;i<8;i++){
        		int a = sj.getContrarioMasCerca(i);
        		if (!sj.estoyMasCercaDeBola()){
        			if (bola.getY()>posicionJugadores[i].getY()){
        				com.add(new ComandoIrA(i,posicionContrarios[a].getX()+15, posicionContrarios[a].getY()+10));
        			}else if (bola.getY()<posicionJugadores[i].getY()){
        				com.add(new ComandoIrA(i,posicionContrarios[a].getX()+15, posicionContrarios[a].getY()-10));
        			}else{
        				com.add(new ComandoIrA(i,posicionContrarios[a].getX()+15, posicionContrarios[a].getY()));
        			}
        		}
        	}
        } else {
        	for (int n=0;n<11;n++){
        		com.add(new ComandoIrA(n,nValores[n][0],nValores[n][1]));
        	}
        }      
        //Movimiento mas cercano a la bola
        int nJug=sj.getMasCercanoDeBola();
        com.add(new ComandoIrA(nJug,bola.getX(), bola.getY()));
       
        //Si tenemos el baln...
       for (int i=1; i<11; i++){
    	   //Si estamos cerca, tirar a puerta
    	   if(bola.x>75){
    		   for (int j=1; j<11; j++){
    			   com.add(new ComandoTiroAPuerta(i,0));
    		   }
    	   }
    	   //Si no...
    	   if(sj.estoyMasCercaDeBola()){
    		   switch (i){
    		   	case 1: {
    		   				int a = sj.getContrarioMasCerca(i);
    		   				if (posicionContrarios[a].getY()>=0){
    		   					//pase al 2o5
    		   					com.add(new ComandoPase(1,5));
    		   					destinoPase=5;
    		   				} else {
    		   					//pase al 4o7
    		   					com.add(new ComandoPase(1,7));
    		   					destinoPase=7;
    		   				}
    		   				break;
    		   			}
    		   	case 2: {	
    		   				//Pase del 2 al 5
    		   				double m56x = (posicionJugadores[5].getX()+posicionJugadores[6].getX())/2;
    		   				double m56y = (posicionJugadores[5].getY()+posicionJugadores[6].getY())/2;
    		   				Triangulo t25m56 = new Triangulo(posicionJugadores[2].getX(), 
    		   						posicionJugadores[2].getY(), posicionJugadores[5].getX(),
    		   						posicionJugadores[5].getY(), m56x, m56y);
    		   				if (!hayContrario(t25m56, posicionContrarios)){
    		   					com.add(new ComandoPase(2,5));
    		   					destinoPase=5;
    		   					break;
    		   				}
    		   				//Pase del 2 al 6
    		   				double d6x = posicionJugadores[6].getX()+25;
    		   				double d6y = posicionJugadores[6].getY()-25;
    		   				double i6x = posicionJugadores[6].getX()-25;
    		   				double i6y = posicionJugadores[6].getY()+25;
    		   				Triangulo t2d6i6 = new Triangulo(posicionJugadores[2].getX(), posicionJugadores[2].getY(),
    		   						d6x, d6y, i6x, i6y);
    		   				if (!hayContrario(t2d6i6, posicionContrarios)){
    		   					com.add(new ComandoPase(2,6));
    		   					destinoPase=6;
    		   					break;
    		   				}
    		   				//Pase del 2 al 3
    		   				double d3x = posicionJugadores[3].getX()+25;
    		   				double d3y = posicionJugadores[3].getY();
    		   				double i3x = posicionJugadores[3].getX()-25;
    		   				double i3y = posicionJugadores[3].getY();
    		   				Triangulo t2d3i3 = new Triangulo(posicionJugadores[2].getX(), posicionJugadores[2].getY(),
    		   						d3x, d3y, i3x, i3y);
    		   				if (!hayContrario(t2d3i3, posicionContrarios)){
    		   					com.add(new ComandoPase(2,3));
    		   					destinoPase=3;
    		   					break;
    		   				}
    		   				//Pase del 2 al 1
    		   				/*double d1x = posicionJugadores[1].getX();
    		   				double d1y = posicionJugadores[1].getY()-25;
    		   				double i1x = posicionJugadores[1].getX();
    		   				double i1y = posicionJugadores[1].getY()+25;
    		   				Triangulo t2d1i1 = new Triangulo(posicionJugadores[2].getX(), posicionJugadores[2].getY(),
    		   						d1x, d1y, i1x, i1y);
    		   				if (!hayContrario(t2d1i1, posicionContrarios)){
    		   					com.add(new ComandoPase(2,1));
    		   					destinoPase=1;
    		   					break;
    		   				}*/
    		   				//Si no se recomienda las anteriores, baln alante por la banda
    		   				com.add(new ComandoPase(2,8));
    		   				destinoPase=8;
    		   				break;
    		   			}//end case 2
    		   	case 3: {
    		   				Rectangulo mitadInferior3 = new Rectangulo(posicionJugadores[3].getX(), posicionJugadores[3].getY(),
    		   						160, posicionJugadores[3].getY(), 160, 120, posicionJugadores[3].getX(), 120);
    		   				Rectangulo mitadSuperior3 = new Rectangulo(posicionJugadores[3].getX(), -120, 160,
    		   						-120, 160, posicionJugadores[3].getX(), posicionJugadores[3].getX(),
    		   						posicionJugadores[3].getY());
    		   				int contrariosAbajo=cuantosContrarios(mitadInferior3, posicionContrarios);
    		   				int contrariosArriba=cuantosContrarios(mitadSuperior3, posicionContrarios);
    		   				if (contrariosAbajo<contrariosArriba){
    		   					//si hay menos contrarios en la parte inferior del campo, bascular hacia ese lado
    		   					
    		   					//Pase del 3 al 7
        		   				double m67x = (posicionJugadores[7].getX()+posicionJugadores[6].getX())/2;
        		   				double m67y = (posicionJugadores[7].getY()+posicionJugadores[6].getY())/2;
        		   				Triangulo t37m67 = new Triangulo(posicionJugadores[3].getX(), 
        		   						posicionJugadores[3].getY(), posicionJugadores[7].getX(),
        		   						posicionJugadores[7].getY(), m67x, m67y);
        		   				if (!hayContrario(t37m67, posicionContrarios)){
        		   					com.add(new ComandoPase(3,7));   
        		   					destinoPase=7;
        		   					break;
        		   				}
        		   				//Pase del 3 al 6
        		   				double d6x = posicionJugadores[6].getX()+25;
        		   				double d6y = posicionJugadores[6].getY()-25;
        		   				double i6x = posicionJugadores[6].getX()-25;
        		   				double i6y = posicionJugadores[6].getY()+25;
        		   				Triangulo t3d6i6 = new Triangulo(posicionJugadores[3].getX(), 
        		   						posicionJugadores[3].getY(), d6x, d6y, i6x, i6y);
        		   				if (!hayContrario(t3d6i6, posicionContrarios)){
        		   					com.add(new ComandoPase(3,6));
        		   					destinoPase=6;
        		   					break;
        		   				}
        		   				//Pase del 3 al 4
        		   				double d4x = posicionJugadores[4].getX()+25;
        		   				double d4y = posicionJugadores[4].getY();
        		   				double i4x = posicionJugadores[4].getX()-25;
        		   				double i4y = posicionJugadores[4].getY();
        		   				Triangulo t3d4i4 = new Triangulo(posicionJugadores[3].getX(), 
        		   						posicionJugadores[3].getY(), d4x, d4y, i4x, i4y);
        		   				if (!hayContrario(t3d4i4, posicionContrarios)){
        		   					com.add(new ComandoPase(3,4));
        		   					destinoPase=4;
        		   					break;
        		   				}
        		   				//Pase del 3 al 1
        		   				/*double d1x = posicionJugadores[1].getX();
        		   				double d1y = posicionJugadores[1].getY()-25;
        		   				double i1x = posicionJugadores[1].getX();
        		   				double i1y = posicionJugadores[1].getY()+25;
        		   				Triangulo t3d1i1 = new Triangulo(posicionJugadores[3].getX(), 
        		   						posicionJugadores[3].getY(), d1x, d1y, i1x, i1y);
        		   				if (!hayContrario(t3d1i1, posicionContrarios)){
        		   					com.add(new ComandoPase(3,1));
        		   					destinoPase=1;
        		   					break;
        		   				}*/
        		   				
    		   				}else{
    		   					//si hay menos contrarios en la parte superior del campo, bascular hacia ese lado
    		   					
    		   					//Pase del 3 al 5
    		   					double m56x = (posicionJugadores[5].getX()+posicionJugadores[6].getX())/2;
        		   				double m56y = (posicionJugadores[5].getY()+posicionJugadores[6].getY())/2;
        		   				Triangulo t35m56 = new Triangulo(posicionJugadores[3].getX(), 
        		   						posicionJugadores[3].getY(), posicionJugadores[5].getX(),
        		   						posicionJugadores[5].getY(), m56x, m56y);
        		   				if (!hayContrario(t35m56, posicionContrarios)){
        		   					com.add(new ComandoPase(3,5));  
        		   					destinoPase=5;
        		   					break;
        		   				}
        		   				//Pase del 3 al 6
        		   				double d6x = posicionJugadores[6].getX()+25;
        		   				double d6y = posicionJugadores[6].getY()-25;
        		   				double i6x = posicionJugadores[6].getX()-25;
        		   				double i6y = posicionJugadores[6].getY()+25;
        		   				Triangulo t3d6i6 = new Triangulo(posicionJugadores[3].getX(), 
        		   						posicionJugadores[3].getY(), d6x, d6y, i6x, i6y);
        		   				if (!hayContrario(t3d6i6, posicionContrarios)){
        		   					com.add(new ComandoPase(3,6));
        		   					destinoPase=6;
        		   					break;
        		   				}
        		   				//Pase del 3 al 2
        		   				double d2x = posicionJugadores[2].getX()-25;
        		   				double d2y = posicionJugadores[2].getY();
        		   				double i2x = posicionJugadores[2].getX()+25;
        		   				double i2y = posicionJugadores[2].getY();
        		   				Triangulo t3d2i2 = new Triangulo(posicionJugadores[3].getX(), 
        		   						posicionJugadores[3].getY(), d2x, d2y, i2x, i2y);
        		   				if (!hayContrario(t3d2i2, posicionContrarios)){
        		   					com.add(new ComandoPase(3,2));
        		   					destinoPase=2;
        		   					break;
        		   				}
        		   				//Pase del 3 al 1
        		   				/*double d1x = posicionJugadores[6].getX();
        		   				double d1y = posicionJugadores[6].getY()-25;
        		   				double i1x = posicionJugadores[6].getX();
        		   				double i1y = posicionJugadores[6].getY()+25;
        		   				Triangulo t3d1i1 = new Triangulo(posicionJugadores[3].getX(), 
        		   						posicionJugadores[3].getY(), d1x, d1y, i1x, i1y);
        		   				if (!hayContrario(t3d1i1, posicionContrarios)){
        		   					com.add(new ComandoPase(3,1));
        		   					destinoPase=1;
        		   					break;
        		   				}*/	
    		   				}
    		   				//Si no se recomienda las anteriores, baln largo a los extremos
    		   				Triangulo t389 = new Triangulo(posicionJugadores[3].getX(), posicionJugadores[3].getY(),
    		   											   posicionJugadores[8].getX(), posicionJugadores[8].getX(),
    		   											   posicionJugadores[9].getX(), posicionJugadores[9].getY());
    		   				Triangulo t3910 = new Triangulo(posicionJugadores[3].getX(), posicionJugadores[3].getY(),
									   						posicionJugadores[9].getX(), posicionJugadores[9].getX(),
									   						posicionJugadores[10].getX(), posicionJugadores[10].getY());
    		   				int nContrarios389 = cuantosContrarios(t389, posicionContrarios);
    		   				int nContrarios3910= cuantosContrarios(t3910, posicionContrarios);
    		   				if (nContrarios389<nContrarios3910){
    		   					com.add(new ComandoPase(3,8));
    		   					destinoPase=8;
    		   				}else{
    		   					com.add(new ComandoPase(3,10));
    		   					destinoPase=10;
    		   				}
    		   				break;
    		   			}//end case 3
    		   	case 4: {
    		   				//Pase del 4 al 7
	   						double m67x = (posicionJugadores[7].getX()+posicionJugadores[6].getX())/2;
	   						double m67y = (posicionJugadores[7].getY()+posicionJugadores[6].getY())/2;
	   						Triangulo t47m67 = new Triangulo(posicionJugadores[4].getX(), 
	   								posicionJugadores[4].getY(), posicionJugadores[7].getX(),
	   								posicionJugadores[7].getY(), m67x, m67y);
	   						if (!hayContrario(t47m67, posicionContrarios)){
	   							com.add(new ComandoPase(4,7));  
	   							destinoPase=7;
	   							break;
	   						}
	   						//Pase del 4 al 6
	   						double d6x = posicionJugadores[6].getX()+25;
	   						double d6y = posicionJugadores[6].getY()-25;
	   						double i6x = posicionJugadores[6].getX()-25;
	   						double i6y = posicionJugadores[6].getY()+25;
	   						Triangulo t4d6i6 = new Triangulo(posicionJugadores[4].getX(), posicionJugadores[4].getY(),
	   								d6x, d6y, i6x, i6y);
	   						if (!hayContrario(t4d6i6, posicionContrarios)){
	   							com.add(new ComandoPase(4,6));
	   							destinoPase=6;
	   							break;
	   						}
	   						//Pase del 4 al 3
	   						double d3x = posicionJugadores[3].getX()-25;
	   						double d3y = posicionJugadores[3].getY();
	   						double i3x = posicionJugadores[3].getX()+25;
	   						double i3y = posicionJugadores[3].getY();
	   						Triangulo t4d3i3 = new Triangulo(posicionJugadores[4].getX(), posicionJugadores[4].getY(),
	   								d3x, d3y, i3x, i3y);
	   						if (!hayContrario(t4d3i3, posicionContrarios)){
	   							com.add(new ComandoPase(4,3));
	   							destinoPase=3;
	   							break;
	   						}
	   						//Pase del 4 al 1
	   						/*double d1x = posicionJugadores[1].getX();
	   						double d1y = posicionJugadores[1].getY()-25;
	   						double i1x = posicionJugadores[1].getX();
	   						double i1y = posicionJugadores[1].getY()+25;
	   						Triangulo t4d1i1 = new Triangulo(posicionJugadores[4].getX(), posicionJugadores[4].getY(),
	   								d1x, d1y, i1x, i1y);
	   						if (!hayContrario(t4d1i1, posicionContrarios)){
	   							com.add(new ComandoPase(4,1));
	   							destinoPase=1;
	   							break;
	   						}*/
	   						//Si no se recomienda las anteriores, baln alante por la banda
	   						com.add(new ComandoPase(4,10));
	   						destinoPase=10;
	   						break;
    		   			}//end case 4
    		   	case 5: {
    		   				//si esta lejos y tiene campo libre, avanzar y mover el resto del ataque
							if (posicionJugadores[5].getX()<60){
								if (!jugadorCerca(posicionContrarios, posicionJugadores[8])){
									com.add(new ComandoGolpearBola(5,posicionJugadores[5].getX()+20,
											posicionJugadores[5].getY()));
								    	if (posicionJugadores[8].getX()-posicionJugadores[5].getX()<50){
											com.add(new ComandoIrA(8, posicionJugadores[5].getX()+50, posicionJugadores[8].getY()));
										}
								    	//com.add(new ComandoIrA(6, 80, 0));
								    	com.add(new ComandoIrA(6,nValores[6][0],nValores[6][1]));
								    	//com.add(new ComandoIrA(7, 80, 80));
								    	com.add(new ComandoIrA(10, 95, 75));
								    	for (int n=0;n<5;n++){
								    		com.add(new ComandoIrA(n,nValores[n][0],nValores[n][1]));
								    	}
								    	com.add(new ComandoIrA(9,nValores[9][0],nValores[9][1]));
								    	com.add(new ComandoIrA(nJug,bola.getX(), bola.getY()));
										break;
								}
								/*Rectangulo campoDelante = new Rectangulo(
										posicionJugadores[5].getX()-20, posicionJugadores[5].getY()-40,
										posicionJugadores[5].getX()+60, posicionJugadores[5].getY()-40,
										posicionJugadores[5].getX()+60, posicionJugadores[5].getY()+40,
										posicionJugadores[5].getX()-20, posicionJugadores[5].getY()+40);
								if (!hayContrario(campoDelante, posicionContrarios)){
									com.add(new ComandoGolpearBola(5,posicionJugadores[5].getX()+20,
										posicionJugadores[5].getY()));
							    	if (posicionJugadores[8].getX()-posicionJugadores[5].getX()<50){
										com.add(new ComandoIrA(8, posicionJugadores[5].getX()+50, posicionJugadores[8].getY()));
									}
							    	//com.add(new ComandoIrA(6, 80, 0));
							    	com.add(new ComandoIrA(6,nValores[6][0],nValores[6][1]));
							    	//com.add(new ComandoIrA(7, 80, 80));
							    	com.add(new ComandoIrA(10, 95, 75));
							    	for (int n=0;n<5;n++){
							    		com.add(new ComandoIrA(n,nValores[n][0],nValores[n][1]));
							    	}
							    	com.add(new ComandoIrA(9,nValores[9][0],nValores[9][1]));
							    	com.add(new ComandoIrA(nJug,bola.getX(), bola.getY()));
									break;
								}*/
							}
    		   				//Si ha subido que tire
    		   				/*if (posicionJugadores[5].getX()>60){
    		   					com.add(new ComandoTiroAPuerta(5,-10));
    		   					break;
    		   				}*/
    		   				//Pase del 5 al 8
	   						double m89x = (posicionJugadores[8].getX()+posicionJugadores[9].getX())/2;
	   						double m89y = (posicionJugadores[8].getY()+posicionJugadores[9].getY())/2;
	   						Triangulo t58m89 = new Triangulo(posicionJugadores[5].getX(), 
	   								posicionJugadores[5].getY(), posicionJugadores[8].getX(),
	   								posicionJugadores[8].getY(), m89x, m89y);
	   						if (!hayContrario(t58m89, posicionContrarios)){
	   							com.add(new ComandoPase(5,8));
	   							destinoPase=8;
	   							break;
	   						}
	   						//Pase del 5 al 9
	   						double d9x = posicionJugadores[9].getX()+25;
	   						double d9y = posicionJugadores[9].getY()-25;
	   						double i9x = posicionJugadores[9].getX()-25;
	   						double i9y = posicionJugadores[9].getY()+25;
	   						Triangulo t5d9i9 = new Triangulo(posicionJugadores[5].getX(), posicionJugadores[5].getY(),
	   								d9x, d9y, i9x, i9y);
	   						if (!hayContrario(t5d9i9, posicionContrarios)){
	   							com.add(new ComandoPase(5,9));
	   							destinoPase=9;
	   							break;
	   						}
	   						//Pase del 5 al 6
	   						double d6x = posicionJugadores[6].getX()+25;
	   						double d6y = posicionJugadores[6].getY();
	   						double i6x = posicionJugadores[6].getX()-25;
	   						double i6y = posicionJugadores[6].getY();
	   						Triangulo t5d6i6 = new Triangulo(posicionJugadores[5].getX(), posicionJugadores[5].getY(),
	   								d6x, d6y, i6x, i6y);
	   						if (!hayContrario(t5d6i6, posicionContrarios)){
	   							com.add(new ComandoPase(5,6));
	   							destinoPase=6;
	   							break;
	   						}
	   						//Si no se recomienda las anteriores, baln alante por la banda
	   						com.add(new ComandoPase(5,8));
	   						destinoPase=8;
	   						break;
    		   			}//end case 5
    		   	case 6: {
    		   				//Si est cerca de portera, tirar
    		   				if (posicionJugadores[6].getX()>45){
    		   					if(posicionJugadores[6].getY()>=0){
    		   						com.add(new ComandoTiroAPuerta(6,-5));
    		   					}else{
    		   						com.add(new ComandoTiroAPuerta(6,5));
    		   					}
    		   					break;
    		   				}
    		   				Rectangulo mitadInferior6 = new Rectangulo(posicionJugadores[6].getX(), posicionJugadores[6].getY(),
    		   						160, posicionJugadores[6].getY(), 160, 120, posicionJugadores[6].getX(), 120);
    		   				Rectangulo mitadSuperior6 = new Rectangulo(posicionJugadores[6].getX(), -120, 160,
    		   						-120, 160, posicionJugadores[6].getX(), posicionJugadores[6].getX(),
    		   						posicionJugadores[6].getY());
    		   				int contrariosAbajo=cuantosContrarios(mitadInferior6, posicionContrarios);
    		   				int contrariosArriba=cuantosContrarios(mitadSuperior6, posicionContrarios);
    		   				if (contrariosAbajo<contrariosArriba){
    		   					//si hay menos contrarios en la parte inferior del campo, bascular hacia ese lado
	   					
    		   					//Pase del 6 al 10
    		   					double m910x = (posicionJugadores[9].getX()+posicionJugadores[10].getX())/2;
    		   					double m910y = (posicionJugadores[9].getY()+posicionJugadores[10].getY())/2;
    		   					Triangulo t610m910 = new Triangulo(posicionJugadores[6].getX(), 
    		   							posicionJugadores[6].getY(), posicionJugadores[10].getX(),
    		   							posicionJugadores[10].getY(), m910x, m910y);
    		   					if (!hayContrario(t610m910, posicionContrarios)){
    		   						com.add(new ComandoPase(6,10)); 
    		   						destinoPase=10;
    		   						break;
    		   					}
    		   					//Pase del 6 al 9
    		   					double d9x = posicionJugadores[9].getX()+25;
    		   					double d9y = posicionJugadores[9].getY()-25;
    		   					double i9x = posicionJugadores[9].getX()-25;
    		   					double i9y = posicionJugadores[9].getY()+25;
    		   					Triangulo t6d9i9 = new Triangulo(posicionJugadores[6].getX(), 
    		   							posicionJugadores[6].getY(), d9x, d9y, i9x, i9y);
    		   					if (!hayContrario(t6d9i9, posicionContrarios)){
    		   						com.add(new ComandoPase(6,9));
    		   						destinoPase=9;
    		   						break;
    		   					}
    		   					//Pase del 6 al 7
    		   					double d7x = posicionJugadores[7].getX()+25;
    		   					double d7y = posicionJugadores[7].getY();
    		   					double i7x = posicionJugadores[7].getX()-25;
    		   					double i7y = posicionJugadores[7].getY();
    		   					Triangulo t6d7i7 = new Triangulo(posicionJugadores[6].getX(), 
    		   							posicionJugadores[6].getY(), d7x, d7y, i7x, i7y);
    		   					if (!hayContrario(t6d7i7, posicionContrarios)){
    		   						com.add(new ComandoPase(6,7));
    		   						destinoPase=7;
    		   						break;
    		   					}
    		   				}else{
    		   					//si hay menos contrarios en la parte superior del campo, bascular hacia ese lado
	   					
    		   					//Pase del 6 al 8
    		   					double m89x = (posicionJugadores[8].getX()+posicionJugadores[9].getX())/2;
    		   					double m89y = (posicionJugadores[8].getY()+posicionJugadores[9].getY())/2;
    		   					Triangulo t68m89 = new Triangulo(posicionJugadores[6].getX(), 
    		   							posicionJugadores[6].getY(), posicionJugadores[8].getX(),
    		   							posicionJugadores[8].getY(), m89x, m89y);
    		   					if (!hayContrario(t68m89, posicionContrarios)){
    		   						com.add(new ComandoPase(6,8));  
    		   						destinoPase=8;
    		   						break;
    		   					}
    		   					//Pase del 6 al 9
    		   					double d9x = posicionJugadores[9].getX()+25;
    		   					double d9y = posicionJugadores[9].getY()-25;
    		   					double i9x = posicionJugadores[9].getX()-25;
    		   					double i9y = posicionJugadores[9].getY()+25;
    		   					Triangulo t6d9i9 = new Triangulo(posicionJugadores[6].getX(), 
    		   							posicionJugadores[6].getY(), d9x, d9y, i9x, i9y);
    		   					if (!hayContrario(t6d9i9, posicionContrarios)){
    		   						com.add(new ComandoPase(6,9));
    		   						destinoPase=9;
    		   						break;
    		   					}
    		   					//Pase del 6 al 5
    		   					double d5x = posicionJugadores[2].getX()-25;
    		   					double d5y = posicionJugadores[2].getY();
    		   					double i5x = posicionJugadores[2].getX()+25;
    		   					double i5y = posicionJugadores[2].getY();
    		   					Triangulo t6d5i5 = new Triangulo(posicionJugadores[6].getX(), 
    		   							posicionJugadores[6].getY(), d5x, d5y, i5x, i5y);
    		   					if (!hayContrario(t6d5i5, posicionContrarios)){
    		   						com.add(new ComandoPase(6,5));
    		   						destinoPase=5;
    		   						break;
    		   					}
    		   				}
    		   				//Si no se recomienda las anteriores, tirar por el lado que menos contrarios haya
    		   				Triangulo t6dchaPorteria = new Triangulo(posicionJugadores[6].getX(), 
    		   							posicionJugadores[6].getY(), -40, 160, posicionJugadores[6].getX(), 160);
    		   				Triangulo t6izdaPorteria = new Triangulo(posicionJugadores[6].getX(), 
    		   							posicionJugadores[6].getY(), 40, 160, posicionJugadores[6].getX(), 160);
    		   				int dcha = cuantosContrarios(t6dchaPorteria, posicionContrarios);
    		   				int izda = cuantosContrarios(t6izdaPorteria, posicionContrarios);
    		   				if (dcha>izda){
    		   					com.add(new ComandoTiroAPuerta(6,10));
    		   				}
    		   				else {
    		   					com.add(new ComandoTiroAPuerta(6,-10));
    		   				}
    		   				break;
    		   			}//end case 6
    		   	case 7: {
    		   				//si esta lejos y tiene campo libre, avanzar y mover el resto del ataque
							if (posicionJugadores[7].getX()<60){
								if (!jugadorCerca(posicionContrarios, posicionJugadores[8])){
									com.add(new ComandoGolpearBola(7,posicionJugadores[7].getX()+20,
											posicionJugadores[7].getY()));
								    	if (posicionJugadores[10].getX()-posicionJugadores[7].getX()<50){
											com.add(new ComandoIrA(10, posicionJugadores[7].getX()+50,
													posicionJugadores[10].getY()));
										}
								    	//com.add(new ComandoIrA(6, 80, 0));
								    	com.add(new ComandoIrA(6,nValores[6][0],nValores[6][1]));
								    	//com.add(new ComandoIrA(5, 80, -80));
								    	com.add(new ComandoIrA(8, 95, -75));
								    	for (int n=0;n<5;n++){
								    		com.add(new ComandoIrA(n,nValores[n][0],nValores[n][1]));
								    	}
								    	com.add(new ComandoIrA(9,nValores[9][0],nValores[9][1]));
								    	com.add(new ComandoIrA(nJug,bola.getX(), bola.getY()));
										break;
								}
								/*Rectangulo campoDelante = new Rectangulo(
										posicionJugadores[7].getX()-20, posicionJugadores[7].getY()-40,
										posicionJugadores[7].getX()+60, posicionJugadores[7].getY()-40,
										posicionJugadores[7].getX()+60, posicionJugadores[7].getY()+40,
										posicionJugadores[7].getX()-20, posicionJugadores[7].getY()+40);
								if (!hayContrario(campoDelante, posicionContrarios)){
									com.add(new ComandoGolpearBola(7,posicionJugadores[7].getX()+20,
										posicionJugadores[7].getY()));
							    	if (posicionJugadores[10].getX()-posicionJugadores[7].getX()<50){
										com.add(new ComandoIrA(10, posicionJugadores[7].getX()+50,
												posicionJugadores[10].getY()));
									}
							    	//com.add(new ComandoIrA(6, 80, 0));
							    	com.add(new ComandoIrA(6,nValores[6][0],nValores[6][1]));
							    	//com.add(new ComandoIrA(5, 80, -80));
							    	com.add(new ComandoIrA(8, 95, -75));
							    	for (int n=0;n<5;n++){
							    		com.add(new ComandoIrA(n,nValores[n][0],nValores[n][1]));
							    	}
							    	com.add(new ComandoIrA(9,nValores[9][0],nValores[9][1]));
							    	com.add(new ComandoIrA(nJug,bola.getX(), bola.getY()));
									break;
								}*/
							}
    		   				//Si ha subido que tire
	   						/*if (posicionJugadores[7].getX()>60){
	   							com.add(new ComandoTiroAPuerta(7,10));
	   							break;
	   						}*/
    		   				//Pase del 7 al 10
							double m910x = (posicionJugadores[9].getX()+posicionJugadores[10].getX())/2;
							double m910y = (posicionJugadores[9].getY()+posicionJugadores[10].getY())/2;
							Triangulo t710m910 = new Triangulo(posicionJugadores[7].getX(), 
								posicionJugadores[7].getY(), posicionJugadores[10].getX(),
								posicionJugadores[10].getY(), m910x, m910y);
							if (!hayContrario(t710m910, posicionContrarios)){
								com.add(new ComandoPase(7,10)); 
								destinoPase=10;
								break;
							}
							//Pase del 7 al 9
							double d9x = posicionJugadores[9].getX()+25;
							double d9y = posicionJugadores[9].getY()-25;
							double i9x = posicionJugadores[9].getX()-25;
							double i9y = posicionJugadores[9].getY()+25;
							Triangulo t7d9i9 = new Triangulo(posicionJugadores[7].getX(), posicionJugadores[7].getY(),
								d9x, d9y, i9x, i9y);
							if (!hayContrario(t7d9i9, posicionContrarios)){
								com.add(new ComandoPase(7,9));
								destinoPase=9;
								break;
							}
							//Pase del 7 al 6
							double d6x = posicionJugadores[6].getX()-25;
							double d6y = posicionJugadores[6].getY();
							double i6x = posicionJugadores[6].getX()+25;
							double i6y = posicionJugadores[6].getY();
							Triangulo t7d6i6 = new Triangulo(posicionJugadores[7].getX(), posicionJugadores[7].getY(),
								d6x, d6y, i6x, i6y);
							if (!hayContrario(t7d6i6, posicionContrarios)){
								com.add(new ComandoPase(7,6));
								destinoPase=6;
								break;
							}
							//Si no se recomienda las anteriores, baln alante por la banda
							com.add(new ComandoPase(7,10));
							destinoPase=10;
							break;
    		   			}//end case 7
    		   	case 8: {
    		   				//si esta lejos y tiene campo libre, avanzar y mover el resto del ataque
    		   				if (posicionJugadores[8].getX()<80){
	    		   				if (!jugadorCerca(posicionContrarios, posicionJugadores[8])){
	    		   					com.add(new ComandoGolpearBola(8,posicionJugadores[8].getX()+20,
			   								posicionJugadores[8].getY()));
			   				    	//com.add(new ComandoIrA(5, 80, -70));
			   				    	//com.add(new ComandoIrA(6, 80, 0));
			   				    	com.add(new ComandoIrA(6,nValores[6][0],nValores[6][1]));
			   				    	//com.add(new ComandoIrA(7, 80, -70));
			   				    	com.add(new ComandoIrA(9, 90, -10));
			   				    	com.add(new ComandoIrA(10, 95, 70));
			   				    	for (int n=0;n<5;n++){
			   				    		com.add(new ComandoIrA(n,nValores[n][0],nValores[n][1]));
			   				    	}	
			   				    	com.add(new ComandoIrA(nJug,bola.getX(), bola.getY()));
			   						break;
	    		   				}
    		   				
    		   					/*Rectangulo campoDelante = new Rectangulo(
    		   							posicionJugadores[8].getX()-20, posicionJugadores[8].getY()-40,
										posicionJugadores[8].getX()+60, posicionJugadores[8].getY()-40,
										posicionJugadores[8].getX()+60, posicionJugadores[8].getY()+40,
										posicionJugadores[8].getX()-20, posicionJugadores[8].getY()+40);
    		   					if (!hayContrario(campoDelante, posicionContrarios)){
    		   						com.add(new ComandoGolpearBola(8,posicionJugadores[8].getX()+20,
    		   								posicionJugadores[8].getY()));
    		   				    	com.add(new ComandoIrA(5, 80, -70));
    		   				    	//com.add(new ComandoIrA(6, 80, 0));
    		   				    	com.add(new ComandoIrA(6,nValores[6][0],nValores[6][1]));
    		   				    	com.add(new ComandoIrA(7, 80, -70));
    		   				    	com.add(new ComandoIrA(9, 90, -10));
    		   				    	com.add(new ComandoIrA(10, 95, 70));
    		   				    	for (int n=0;n<5;n++){
    		   				    		com.add(new ComandoIrA(n,nValores[n][0],nValores[n][1]));
    		   				    	}	
    		   				    	com.add(new ComandoIrA(nJug,bola.getX(), bola.getY()));
    		   						break;
    		   					}*/
    		   				}
    		   				Triangulo t8tiro = new Triangulo(posicionJugadores[8].getX(), posicionJugadores[8].getY(),
    		   						160, -60, 160, 30);
    		   				int contrariosAnguloTiro = cuantosContrarios(t8tiro, posicionContrarios);
    		   				if (contrariosAnguloTiro<2){
    		   					//si hay menos de 2 jugadores en angulo de tiro, tirar
    		   					com.add(new ComandoTiroAPuerta(8,-15));
    		   				} else {
    		   					//sino pasar
    		   					com.add(new ComandoPase(8,9));
    		   					destinoPase=9;
    		   				}
    		   				break;
    		   			}//end case 8
    		   	case 9: {
    		   				Triangulo t9tiro = new Triangulo(posicionJugadores[9].getX(), posicionJugadores[9].getY(),
    		   						160, -40, 160, 40);
    		   				int contrariosAnguloTiro = cuantosContrarios(t9tiro, posicionContrarios);
    		   				if (contrariosAnguloTiro<5){
    		   					//si hay menos de 3 jugadores en angulo de tiro, tirar al lado contrario del portero
    		   					if (posicionContrarios[0].getY()>0){
    		   						//si esta abajo, tirar arriba
    		   						com.add(new ComandoTiroAPuerta(9,2));
    		   					} else {
    		   						//si esta arriba o en el centro, tirar abajo
    		   						com.add(new ComandoTiroAPuerta(9,-2));
    		   					}
    		   				} else {
    		   					//si hay 3 o + jugadores en angulo de tiro, abrir al extremo ms solo
    		   					Triangulo t89cp = new Triangulo(posicionJugadores[8].getX(), posicionJugadores[8].getY(),
    		   							posicionJugadores[9].getX(), posicionJugadores[9].getY(),
    		   							posicionJugadores[9].getX(), 160);
    		   					Triangulo t810cp = new Triangulo(posicionJugadores[8].getX(), posicionJugadores[8].getY(),
    		   							posicionJugadores[10].getX(), posicionJugadores[10].getY(),
    		   							posicionJugadores[10].getX(), 160);
    		   					int contrariosPaseA8 = cuantosContrarios(t89cp, posicionContrarios);
    		   					int contrariosPaseA10 = cuantosContrarios(t810cp, posicionContrarios);
    		   					if (contrariosPaseA8<contrariosPaseA10){
    		   						com.add(new ComandoPase(9,8));
    		   						destinoPase=8;
    		   						
    		   					} else {
    		   						com.add(new ComandoPase(9,10));
    		   						destinoPase=10;
    		   					}
    		   				}
    		   				break;
    		   			}//end case 9
    		   	case 10:{
    		   				//Si saca de centro, tira a puerta
    		   				if ((bola.getX()==0) && (bola.getY()==0)){
    		   					com.add(new ComandoTiroAPuerta(10, 3));
    		   					/*Rectangulo mitadSuperior = new Rectangulo(0, 0, 0, -120, 160, -120, 160, 0);
    		   					Rectangulo mitadInferior = new Rectangulo(0, 0, 0, 120, 160, 120, 160, 0);
    		   					int nContrariosSuperior = cuantosContrarios(mitadSuperior, posicionContrarios);
    		   					int nContrariosInferior = cuantosContrarios(mitadInferior, posicionContrarios);
    		   					if (nContrariosSuperior<nContrariosInferior){
    		   						com.add(new ComandoPase(10,5));
    		   					} else {
    		   						com.add(new ComandoPase(10,5));
    		   					}*/
    		   					break;
    		   				}
    		   				//si esta lejos y tiene campo libre, avanzar y mover el resto del ataque
    		   				if (posicionJugadores[10].getX()<80){
	    		   				if (!jugadorCerca(posicionContrarios, posicionJugadores[10])){
	    		   					com.add(new ComandoGolpearBola(10,posicionJugadores[10].getX()+20,
	   										posicionJugadores[10].getY()));
	   						    	//com.add(new ComandoIrA(5, 80, -70));
	   						    	//com.add(new ComandoIrA(6, 80, 0));
	   						    	com.add(new ComandoIrA(6,nValores[6][0],nValores[6][1]));
	   						    	//com.add(new ComandoIrA(7, 80, -70));
	   						    	com.add(new ComandoIrA(9, 90, 10));
	   						    	com.add(new ComandoIrA(8, 95, -70));
	   						    	for (int n=0;n<5;n++){
	   						    		com.add(new ComandoIrA(n,nValores[n][0],nValores[n][1]));
	   						    	}
	   						    	com.add(new ComandoIrA(nJug,bola.getX(), bola.getY()));
	   								break;
	    		   				}
	   							
	   							/*Rectangulo campoDelante = new Rectangulo(
	   									posicionJugadores[10].getX()-20, posicionJugadores[10].getY()-40,
										posicionJugadores[10].getX()+60, posicionJugadores[10].getY()-40,
										posicionJugadores[10].getX()+60, posicionJugadores[10].getY()+40,
										posicionJugadores[10].getX()-20, posicionJugadores[10].getY()+40);
	   							if (!hayContrario(campoDelante, posicionContrarios)){
	   								com.add(new ComandoGolpearBola(10,posicionJugadores[10].getX()+20,
	   										posicionJugadores[10].getY()));
	   						    	com.add(new ComandoIrA(5, 80, -70));
	   						    	//com.add(new ComandoIrA(6, 80, 0));
	   						    	com.add(new ComandoIrA(6,nValores[6][0],nValores[6][1]));
	   						    	com.add(new ComandoIrA(7, 80, -70));
	   						    	com.add(new ComandoIrA(9, 90, 10));
	   						    	com.add(new ComandoIrA(8, 95, -70));
	   						    	for (int n=0;n<5;n++){
	   						    		com.add(new ComandoIrA(n,nValores[n][0],nValores[n][1]));
	   						    	}
	   						    	com.add(new ComandoIrA(nJug,bola.getX(), bola.getY()));
	   								break;
	   							}*/
	   						}
    		   				Triangulo t10tiro = new Triangulo(posicionJugadores[10].getX(), posicionJugadores[10].getY(),
    		   						160, 60, 160, -30);
    		   				int contrariosAnguloTiro = cuantosContrarios(t10tiro, posicionContrarios);
    		   				if (contrariosAnguloTiro<2){
    		   					//si hay menos de 2 jugadores en angulo de tiro, tirar
    		   					com.add(new ComandoTiroAPuerta(10,15));
    		   				} else {
    		   					//sino pasar
    		   					com.add(new ComandoPase(10,9));
    		   					destinoPase=9;
    		   				}
    		   				break;
    		   			}//end case 10
    		   }//end switch
    	   }//end if
       }//end for        

        //Movimiento portero
        double x1 = bola.getX();
        double y1 = bola.getY();
        double x2 = -150;
        double y2 = y0+((y1-y0)/(x1-x0))*x2-((y1-y0)/(x1-x0))*x0;
        if ((x1<-110)&&(y1<70)&&(y1>-70)){
        	com.add(new ComandoIrA(0,x1,y1));
        } else {
        	if (y2<-30.0) y2=-30.0;
            if (y2>30.0) y2=30.0;
            
            if ((x0==x1) && (y0==y1) && x1<-10){
            	int y = (int)y1;
            	com.add(new ComandoIrA(0,nValores[0][0], y));
            } else {
            	int y = (int)y2;
            	com.add(new ComandoIrA(0,nValores[0][0], y));
            }
        }
        //El portero pasa:
        //si est escorado arriba, le pasa al mediocampista de la banda de arriba
        //si est escorado abajo, le pasa al mediocampista de la banda de abajo
        //si est centrado al que est mas despejado delos mediocampistas
        if (posicionJugadores[0].getY()>65){
        	com.add(new ComandoPase(0,3));
        }else if (posicionJugadores[0].getY()<-65){
        	com.add(new ComandoPase(0,5));
        }else{
	        double d5x = posicionJugadores[5].getX()-25;
	        double d5y = posicionJugadores[5].getY()-25;
	        double i5x = posicionJugadores[5].getX()+25;
	        double i5y = posicionJugadores[5].getY()+25;
	        double d6x = posicionJugadores[6].getX();
	        double d6y = posicionJugadores[6].getY()-25;
	        double i6x = posicionJugadores[6].getX();
	        double i6y = posicionJugadores[6].getY()+25;
	        double d7x = posicionJugadores[7].getX()+25;
	        double d7y = posicionJugadores[7].getY()-25;
	        double i7x = posicionJugadores[7].getX()-25;
	        double i7y = posicionJugadores[7].getY()+25;
	        Triangulo t0d5i5 = new Triangulo(posicionJugadores[0].getX(), posicionJugadores[0].getY(), d5x, d5y, i5x, i5y);
	        Triangulo t0d6i6 = new Triangulo(posicionJugadores[0].getX(), posicionJugadores[0].getY(), d6x, d6y, i6x, i6y);
	        Triangulo t0d7i7 = new Triangulo(posicionJugadores[0].getX(), posicionJugadores[0].getY(), d7x, d7y, i7x, i7y);
	        int contrarios5 = cuantosContrarios(t0d5i5, posicionContrarios);
	        int contrarios6 = cuantosContrarios(t0d6i6, posicionContrarios);
	        int contrarios7 = cuantosContrarios(t0d7i7, posicionContrarios);
	        if ((contrarios5<=contrarios6) && (contrarios5<=contrarios7)){
	        	com.add(new ComandoPase(0,3));
	        } else if ((contrarios7<=contrarios6) && (contrarios7<=contrarios5)){
	        	com.add(new ComandoPase(0,4));
	        } else {
	        	com.add(new ComandoPase(0,5));
	        }
        }
        x0 = bola.getX();
        y0 = bola.getY();
        return com;
    }
    
    //Mtodo que verifica si hay contrarios en un triangulo dado
    public static boolean hayContrario(Triangulo t, Point[] posicionContrarios){
    	for (int j=0; j<11; j++){
				double contrarioX=posicionContrarios[j].getX();
				double contrarioY=posicionContrarios[j].getY();
				if (t.isInTriangulo(contrarioX, contrarioY)){
					return true;
				}
			}
    	return false;
    }
    
    //Mtodo que verifica si hay contrarios en un rectangulo dado
    public static boolean hayContrario(Rectangulo r, Point[] posicionContrarios){
    	for (int j=0; j<11; j++){
				double contrarioX=posicionContrarios[j].getX();
				double contrarioY=posicionContrarios[j].getY();
				if (r.isInRectangulo(contrarioX, contrarioY)){
					return true;
				}
			}
    	return false;
    }
   
    //Mtodo que cuenta los contrarios en un rectangulo dado
    public static int cuantosContrarios(Triangulo t, Point[] posicionContrarios){
    	int nContrarios=0;
    	for (int j=0; j<11; j++){
				double contrarioX=posicionContrarios[j].getX();
				double contrarioY=posicionContrarios[j].getY();
				if (t.isInTriangulo(contrarioX, contrarioY)){
					nContrarios++;
				}
			}
    	return nContrarios;
    }
    
    //Mtodo que cuenta los contrarios en un rectangulo dado
    public static int cuantosContrarios(Rectangulo r, Point[] posicionContrarios){
    	int nContrarios=0;
    	for (int j=0; j<11; j++){
				double contrarioX=posicionContrarios[j].getX();
				double contrarioY=posicionContrarios[j].getY();
				if (r.isInRectangulo(contrarioX, contrarioY)){
					nContrarios++;
				}
			}
    	return nContrarios;
    }
    // jugador cerca nos indica si hay algn jugador contrario en una distancia < 625
    public boolean jugadorCerca(Point[] posicionContrarios, Point jugadorMio)
    {
        for (int j = 0; j < 11; j++){
            if (distancia_2(posicionContrarios[j], jugadorMio) < 425){
                    return true;
        	}
        }
        return false;
    }
    public static double distancia_2(Point p1, Point p2)
    {
        return Math.pow(p1.x-p2.x,2)+Math.pow(p1.y-p2.y,2);
    }
}
